// 实现标绘面板中的功能
import * as olProj from 'ol/proj' // 坐标变换使用
import { plot } from './plotting.js'
import { Fill, Stroke, Circle as CircleStyle, Style, Text } from 'ol/style' // 注意CircleStyle是样式
// import DragPan from 'ol/interaction/DragPan'
// import Draw from 'ol/interaction/Draw'
import Point from 'ol/geom/Point'
import LineString from 'ol/geom/LineString'
import geoCircle from 'ol/geom/Circle' // 注意geoCircle是圆形
import Polygon from 'ol/geom/Polygon'
import Feature from 'ol/Feature'
import { defineComponent, getCurrentInstance } from "vue";

let proxy
export default defineComponent({
  data () {
    return {
      isSave: false, // 保存状态标志位
      proxy: ""
    }
  },
  watch: {
    // watch
  },
  created () {
    proxy = getCurrentInstance().proxy;
  },
  methods: {
    /**
     * @description 休眠-sleep
     * @param ms {number}休眠时间，单位是毫秒
     * @return
     */
    sleep (ms) {
      return new Promise(resolve => setTimeout(resolve, ms))
    },

    // 根据军标名称获取SVG数据- （将数据写入vertor的svgSata中；返回SVG数据）
    async getSVGDataByID (plotID, iPlotSvgArr) {
      const plotSVG = iPlotSvgArr?.[plotID] || ""
      if (plotSVG) {
        proxy.$refs.pVec.svgData = plotSVG
      } else {
        proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(plotID)
        // 保存到军标数组中
        proxy.iPlotSvgArr[plotID] = proxy.$refs.pVec.svgData
      }
      return proxy.$refs.pVec.svgData
    },

    /**
     * @description 保存标绘数据
     * @param null
     * @return
     */
    saveData () {
      // let blob = new Blob(JSON.stringify(proxy.xData))
      // saveAs(blob, '标绘文件导出测试.txt')
      for (let i = 0; i < proxy.xData.length; i++) { // 标绘中的文字元素换行处理
        const xId = proxy.xData[i].id
        const iType = xId.substr(0, 4)
        if (iType === 'text') {
          const iText = proxy.xData[i].style.text
          proxy.xData[i].style.text = iText.replace(/\n/g, '\\n')
        }
      }
      // console.log(JSON.stringify(proxy.xData))
      // return proxy.xData
      // 重新组织保存的数据
      const iUnit = proxy.getUnit()
      // const sRCS = proxy.iMap.getView().getProjection().getCode()
      const sRCS = proxy.$parent.conf.RCS
      // let sWidth = proxy.strokeWidth
      const plotData = { fileID: proxy.plotFileID, unit: iUnit, RCS: sRCS, strokeWidth: proxy.strokeWidth, data: proxy.xData }
      // console.log(JSON.stringify(plotData))
      return plotData
    },

    // new 保存数据到数据库-- save2db --需要暴露给用户-->layerIO
    savePlotData2DB_old () {
      if (proxy.isSave) return
      if (Object.keys(proxy.plotRecord).length < 1) return
      proxy.isSave = true
      console.log(proxy.plotRecord)
      // savePlotData(proxy.plotRecord).then(res => {
      //   console.log(res)
      //   // 删除数据
      //   const iNum = Object.keys(proxy.plotRecord).length
      //   // proxy.plotRecord = {} // .splice(0, iNum)
      //   for (var key in proxy.plotRecord) {
      //     delete proxy.plotRecord[key]
      //   }
      //   console.log(iNum, proxy.plotRecord)
      //   // 修改标志位
      //   proxy.isSave = false
      // })
    },
    // -- 改提供参数方式(可以指定要保存到数据库的对象--plotRecord标绘动作记录)
    savePlotData2DB (plotRecord = proxy.plotRecord) {
      if (proxy.isSave) return
      if (Object.keys(plotRecord).length < 1) return
      proxy.isSave = true
      for (const key in plotRecord) {
        console.log(plotRecord[key])
      }

      // savePlotData(plotRecord).then(res => {
      //   console.log(res)
      //   // 删除数据
      //   const iNum = Object.keys(plotRecord).length
      //   for (var key in plotRecord) {
      //     delete plotRecord[key]
      //   }
      //   console.log(iNum, plotRecord)
      //   // 修改标志位
      //   proxy.isSave = false
      // })
    },

    /**
     * 将xData的数据结构转成数据库的结构，然后保存到数据库
     */
    savexData2DB () {
      const dbStruct = {} // 用来保存提交到数据库的每条标绘记录
      const oAction = {} // 单条标绘数据--数据库表结构
      const currTime = new Date().getTime()
      // 是否要清空xData
      console.log(proxy.xData.length)
      for (let i = 0; i < proxy.xData.length; i++) {
        var plotJson = proxy.xData[i]
        console.log(plotJson.id)
        oAction.action = 'C'
        oAction.plot_id = proxy.plotFileID
        oAction.element_id = plotJson.id
        oAction.creator = proxy.iUser // plotJson['owner'] // proxy.iUser
        oAction.ctime = currTime // plotJson.TS
        oAction.modifier = proxy.iUser // plotJson['owner'] // proxy.iUser
        oAction.mtime = currTime // plotJson.TS
        oAction.content = JSON.parse(JSON.stringify(plotJson))
        dbStruct[oAction.element_id] = JSON.parse(JSON.stringify(oAction)) // 如果不json转换，会覆盖？全都是最后一个
        // dbStruct[plotJson.id] = JSON.parse(JSON.stringify(oAction))
      }
      for (var key in dbStruct) {
        console.log(key, dbStruct[key])
      }

      if (Object.keys(dbStruct).length > 0) {
        proxy.savePlotData2DB(dbStruct)
      }
    },
    // 根据元素数据绘制元素(获取到时间戳数据后，更新当前标绘文件的元素)
    // updatePlotElement1 (plotElement) {
    //   const action = plotElement.action.toLowerCase()
    //   const plotID = plotElement.element_id
    //   if (action === 'c') {
    //     // 查找创建的军标是否存在，存在退出
    //     if (proxy.getPlotFromXData(plotID)) return
    //     // 创建军标
    //     let oPlotData = plotElement.content.replace(/None/g, 'null')
    //     oPlotData = eval('(' + oPlotData + ')')
    //     proxy.drawPlotElement(oPlotData)
    //   } else if (action === 'u') {
    //     // 查找要修改的聚标是否存在，不存在退出
    //     if (proxy.getPlotFromXData(plotID)) {
    //       proxy.delPlot(plotID, false)
    //       let oPlotData = plotElement.content.replace(/None/g, 'null')
    //       oPlotData = eval('(' + oPlotData + ')')
    //       // 删除后绘制
    //       proxy.drawPlotElement(oPlotData)
    //       // proxy.updatePlot(plotID, oPlotData)
    //     }
    //   } else if (action === 'd') {
    //     // 查找标绘的元素是否存在，存在删除
    //     // proxy.clearPlotByGID(delID) // 删除绘制的军标图像
    //     // proxy.delPlotFromxDataByID(delID) // 删除保存在xData中的数据
    //     proxy.delPlot(plotID, false)
    //   }
    // },
    // 加载数据从数据库
    loadPlotData (isAllData = false) {
      console.log(proxy.plotDataTime) // 加载时间
      // 如果加载时间为空--获取当前时间--全量加载
      // const loadTime = new Date().getTime() // 没有载入时间，先创建载入时间
      proxy.clearCtrlPoint()
      if (proxy.plotDataTime && !isAllData) {
      } else {
      }
    },

    // 根据提供的军标数据绘制军标
    async drawPlotElement (plotData) {
      if (!plotData) return
      const iPlot = plotData
      console.log(plotData.name)
      const pName = iPlot.name
      // let id = iPlot.id
      // let cp = iPlot.cp
      // let bbox = iPlot.boxWH
      // let rotate = iPlot.rotate
      // let scale = iPlot.scale
      // let color = iPlot.color
      // let unit = iPlot.unit
      const style = iPlot.style
      let lineWidth = 0
      if (style) { // 如果有样式数据-初始为空
        if (style.width) { // 如果线有宽度设置
          lineWidth = style.width
        }
      }
      if (!lineWidth) {
        lineWidth = proxy.strokeWidth
      }
      // console.log(iPlot, lineWidth)
      let iType = pName.toLowerCase()
      const shortName = iType.substr(0, 4)
      if (shortName === 'icon' || shortName === 'dire' || shortName === 'mult' || shortName === 'hand' || shortName === 'ddir') {
        iType = shortName
      }
      // console.log(iType)
      // 根据类型绘制载入军标
      let iGeom = null
      let iFeature = null
      let iStyle = null
      let cp1 = null
      let cp2 = null
      let r = null
      switch (iType) {
        case 'linestring':
          // 绘制线
          iGeom = new LineString(iPlot.cp) // 生成线所需点！
          iFeature = new Feature(iGeom) // 生成feature
          // 需要添加控制点属性--待添加
          // iFeature.setProperties({gid:gID})
          iFeature.set('gid', iPlot.id)
          iFeature.set('type', 'PLOT')
          // 获取样式
          iStyle = iPlot.style
          // 设置样式
          iFeature.setStyle(new Style({
            fill: new Fill({ // ol.style.Fill
              color: iStyle.fill
            }),
            stroke: new Stroke({ // ol.style.Stroke
              color: iStyle.stroke,
              // width: iStyle.width,
              width: proxy.strokeWidth,
              lineDash: iStyle.lineDash
            })
          }))
          // 将绘制的军标加入军标层
          proxy.plottingLayer.getSource().addFeature(iFeature)
          break
        case 'polygon':
          // 绘制多边形
          // console.log(iPlot.cp)
          iGeom = new Polygon(iPlot.cp) // 生成线所需点！
          iFeature = new Feature(iGeom) // 生成feature
          // 需要添加控制点属性--待添加
          // iFeature.setProperties({gid:gID})
          iFeature.set('gid', iPlot.id)
          iFeature.set('type', 'PLOT')
          if (iPlot.mark) {
            iFeature.set('mark', iPlot.mark)
          }
          // 获取样式
          iStyle = iPlot.style
          // 设置样式
          iFeature.setStyle(new Style({
            fill: new Fill({ // ol.style.Fill
              color: iStyle.fill
            }),
            stroke: new Stroke({ // ol.style.Stroke
              color: iStyle.stroke,
              // width: iStyle.width,
              width: proxy.strokeWidth,
              lineDash: iStyle.lineDash
            })
          }))
          // 将绘制的军标加入军标层
          proxy.plottingLayer.getSource().addFeature(iFeature)
          break
        case 'circle':
          if (iPlot.cp.length < 2) return // 圆需要两个控制点
          cp1 = iPlot.cp[0]
          cp2 = iPlot.cp[1]
          // 求两个点的距离(半径)--可能需要进行坐标转换，转换到3857，计算长度。（坐标转换）
          r = plot.CalLengthOfTwoPoints(cp1, cp2)
          // 绘制圆--new Circle(center, opt_radius)
          // iGeom = new geoCircle(iPlot.cp[0], iPlot.cp[1][0])  // 生成线所需点！
          iGeom = new geoCircle(cp1, r)
          iFeature = new Feature(iGeom) // 生成feature
          // 需要添加控制点属性--待添加
          // iFeature.setProperties({gid:gID})
          iFeature.set('gid', iPlot.id)
          iFeature.set('type', 'PLOT')
          // 获取样式
          iStyle = iPlot.style
          // 设置样式
          iFeature.setStyle(new Style({
            fill: new Fill({ // ol.style.Fill
              color: iStyle.fill
            }),
            stroke: new Stroke({ // ol.style.Stroke
              color: iStyle.stroke,
              // width: iStyle.width,
              width: proxy.strokeWidth,
              lineDash: iStyle.lineDash
            })
          }))
          // 将绘制的军标加入军标层
          proxy.plottingLayer.getSource().addFeature(iFeature)
          break
        case 'icon':
          // 清空原有svg数据
          proxy.$refs.pVec.clearPlotData()
          // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
          // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
          await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
          // await proxy.sleep(100)
          if (iPlot.cp.length > 0) {
            // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}；以下方法自动将地理坐标转换成品目坐标
            proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
            // console.log(proxy.plot_geometries)
            // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth iPlot.color
            proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
            // 将军标绘制到标绘层（样式处理）
            proxy.geom2Featrue(proxy.plot_geometries)
          }
          break
        case 'dire':
        case 'ddir':
          // 绘制svg固定军标和方向军标
          // 清空原有svg数据
          proxy.$refs.pVec.clearPlotData()
          // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
          // console.log(iPlot.name)
          // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name)
          await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
          // await proxy.sleep(100)
          // 调用getFeature方法，分析svg和生成数据
          if (iPlot.cp.length > 1) {
            // 将地理坐标转换成屏幕坐标（createSVGPlot新方法中已经自动转换坐标）
            // let cp1 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[0]) // 控制点1：中心点
            // let cp2 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[1]) // 控制点2：方向点
            // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
            // proxy.plot_geometries = proxy.$refs.pVec.getFeature([cp1, cp2], iType, iPlot.name, proxy.iMap)
            proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
            // 将军标绘制到标绘层（样式处理）
            // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth
            proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
            proxy.geom2Featrue(proxy.plot_geometries)
            // proxy.createSVGPlot(iPlot)
          }
          break
        case 'mult':
          // 绘制方向自由变化军标；如：箭头
          let iMaxPoints = null
          // 调用getFeature方法，分析svg和生成数据
          let funName = iPlot.name.split('_')[1]
          // 获取绘制点数_名称最后一位
          const maxPnt = funName.substr(funName.length - 1, 1)
          // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
          if (!isNaN(maxPnt)) {
            iMaxPoints = parseInt(maxPnt)
            funName = funName.substr(0, funName.length - 1)
          }
          // console.log(funName)
          if (!funName) return
          // 查看方法是否存在，不存在退出！
          const func = plot.getFunc(funName)
          // 方法不存在退出绘制！
          if (!func) return
          // 查看控制点数是否满足绘制要求
          if (iMaxPoints) { // 是否有绘制控制点的数量要求
            if (iPlot.cp.length !== iMaxPoints) return
          }
          proxy.plot_geometries = func(iPlot.cp)
          // 设置样式添加到军标层
          const gID = iPlot.id
          // let iStyle = {
          iStyle = {
            fill: 'none', // proxy.currColor,
            stroke: iPlot.color,
            width: proxy.strokeWidth
          }
          console.log(proxy.iType)
          // if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts') {
          //   iStyle.fill = iPlot.color
          //   iStyle.width = 0
          // }
          for (let i = 0; i < proxy.plot_geometries.geoData.length; i++) {
            // let iType = proxy.plot_geometries.geoData[i].type
            proxy.plot_geometries.geoData[i].gid = gID
            // proxy.plot_geometries.geoData[i].style = iStyle
            proxy.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
          }
          // 实心箭头和虚线箭头样式设置（需要调整-见下面）
          if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_pathArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
            proxy.plot_geometries.geoData[0].style.fill = iPlot.color
            proxy.plot_geometries.geoData[0].style.width = 0
          }
          // 新添加的带轮线（箭头要填充！）
          if (iPlot.name === 'mult_getCyyLine') {
            // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
            proxy.plot_geometries.geoData[0].style.fill = iPlot.color
            proxy.plot_geometries.geoData[0].style.width = 0
            proxy.plot_geometries.geoData[2].style.stroke = '#000000'
            proxy.plot_geometries.geoData[2].color = '#000000'
            // console.log(proxy.currPlot, proxy.currPlot.cp.length)
            if (iPlot.cp.length === 2) {
              const cp1 = iPlot.cp[0]
              const cp2 = iPlot.cp[1]
              const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
              iPlot.cp.splice(1, 0, midPnt) // 如果两个控制点，需要在添加一个
            }
          }
          // 摩托化行进
          if (iPlot.name === 'mult_getMotorLine') {
            // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
            proxy.plot_geometries.geoData[0].style.fill = iPlot.color
            proxy.plot_geometries.geoData[0].style.width = 0
            // console.log(proxy.currPlot, proxy.currPlot.cp.length)
            if (iPlot.cp.length === 2) {
              const cp1 = iPlot.cp[0]
              const cp2 = iPlot.cp[1]
              const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
              iPlot.cp.splice(1, 0, midPnt)
            }
          }
          // 伴随线
          if (iPlot.name === 'mult_getFollowLine') {
            // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
            proxy.plot_geometries.geoData[0].style.fill = iPlot.color
            proxy.plot_geometries.geoData[0].style.width = 0
            proxy.plot_geometries.geoData[2].style.stroke = '#DEB887'
            // console.log(proxy.currPlot, proxy.currPlot.cp.length)
            if (iPlot.cp.length === 2) {
              const cp1 = iPlot.cp[0]
              const cp2 = iPlot.cp[1]
              const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
              iPlot.cp.splice(1, 0, midPnt)
            }
          }
          // 虚线的处理
          if (iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
            proxy.plot_geometries.geoData[1].style.lineDash = [20, 10]
          }
          // console.log(proxy.plot_geometries)
          // 将标绘图形加入标绘层
          proxy.geom2Featrue()
          // proxy.loadGeom2Featrue() --否：拖动控制点时颜色会变成当前色
          break
        case 'point':
          // console.log(iPlot)
          const xID = iPlot.id.substr(0, 4)
          if (xID === 'text') {
            const iText = iPlot.style.text
            iPlot.style.text = iText.replace(/\\n/g, '\n')
          }
          proxy.createTxtPlot(iPlot)
          break
        default:
        // 默认代码块
      }
      // 将xData重新调入
      proxy.xData.push(plotData)
      // console.log(proxy.xData)
    },
    // --
    async updatePlotElement (plotData) {
      // 删除已经绘制的数据,和军标绘制数据
      // proxy.clearData()
      // proxy.xData.splice(0, proxy.xData.length)
      // 添加时间戳--时间戳数据
      proxy.plotDataTime = new Date().getTime()
      console.log(proxy.plotDataTime)
      // 循环绘制每一个军标

      for (let i = 0; i < plotData.length; i++) {
        // const iPlot = plotData[i]
        let iPlot = null
        const action = plotData[i].action.toLowerCase()
        const plotID = plotData[i].element_id
        // console.log(plotData[i].mtime)
        proxy.sleep(200)
        if (action === 'c') {
          // 查找创建的军标是否存在，存在退出
          if (proxy.getPlotFromXData(plotID)) continue
          // 创建军标
          const oPlotData = plotData[i].content.replace(/None/g, 'null')
          iPlot = eval('(' + oPlotData + ')')
        } else if (action === 'u') {
          // 查找要修改的聚标是否存在，不存在退出
          if (proxy.getPlotFromXData(plotID)) {
            proxy.delPlot(plotID, false) // 文字关联，如果删了关联链也就没了，是否可以不删除，直接更新
            const oPlotData = plotData[i].content.replace(/None/g, 'null')
            iPlot = eval('(' + oPlotData + ')')
          } else {
            // 如果是文字-创建后改内容就直接成U了--除非改成所有步骤都记录下来
            const oPlotData = plotData[i].content.replace(/None/g, 'null')
            iPlot = eval('(' + oPlotData + ')')
          }
        } else if (action === 'd') {
          proxy.delPlot(plotID, false)
          continue
        }
        // console.log(iPlot)
        const pName = iPlot.name
        // let id = iPlot.id
        // let cp = iPlot.cp
        // let bbox = iPlot.boxWH
        // let rotate = iPlot.rotate
        // let scale = iPlot.scale
        // let color = iPlot.color
        // let unit = iPlot.unit
        const style = iPlot.style
        let lineWidth = 0
        if (style) { // 如果有样式数据-初始为空
          if (style.width) { // 如果线有宽度设置
            lineWidth = style.width
          }
        }
        if (!lineWidth) {
          lineWidth = proxy.strokeWidth
        }
        // console.log(iPlot, lineWidth)
        let iType = pName.toLowerCase()
        const shortName = iType.substr(0, 4)
        if (shortName === 'icon' || shortName === 'dire' || shortName === 'mult' || shortName === 'hand' || shortName === 'ddir') {
          iType = shortName
        }
        // console.log(iType)
        // 根据类型绘制载入军标
        let iGeom = null
        let iFeature = null
        let iStyle = null
        let cp1 = null
        let cp2 = null
        let r = null
        switch (iType) {
          case 'linestring':
            // 绘制线
            iGeom = new LineString(iPlot.cp) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'polygon':
            // 绘制多边形
            // console.log(iPlot.cp)
            iGeom = new Polygon(iPlot.cp) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            if (iPlot.mark) {
              iFeature.set('mark', iPlot.mark)
            }
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'circle':
            if (iPlot.cp.length < 2) return // 圆需要两个控制点
            cp1 = iPlot.cp[0]
            cp2 = iPlot.cp[1]
            // 求两个点的距离(半径)--可能需要进行坐标转换，转换到3857，计算长度。（坐标转换）
            r = plot.CalLengthOfTwoPoints(cp1, cp2)
            // 绘制圆--new Circle(center, opt_radius)
            // iGeom = new geoCircle(iPlot.cp[0], iPlot.cp[1][0])  // 生成线所需点！
            iGeom = new geoCircle(cp1, r)
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'icon':
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            if (iPlot.cp.length > 0) {
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}；以下方法自动将地理坐标转换成品目坐标
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // console.log(proxy.plot_geometries)
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth iPlot.color
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              // 将军标绘制到标绘层（样式处理）
              proxy.geom2Featrue(proxy.plot_geometries)
            }
            break
          case 'dire':
          case 'ddir':
            // 绘制svg固定军标和方向军标
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // console.log(iPlot.name)
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name)
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            // 调用getFeature方法，分析svg和生成数据
            if (iPlot.cp.length > 1) {
              // 将地理坐标转换成屏幕坐标（createSVGPlot新方法中已经自动转换坐标）
              // let cp1 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[0]) // 控制点1：中心点
              // let cp2 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[1]) // 控制点2：方向点
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
              // proxy.plot_geometries = proxy.$refs.pVec.getFeature([cp1, cp2], iType, iPlot.name, proxy.iMap)
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // 将军标绘制到标绘层（样式处理）
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              proxy.geom2Featrue(proxy.plot_geometries)
              // proxy.createSVGPlot(iPlot)
            }
            break
          case 'mult':
            // 绘制方向自由变化军标；如：箭头
            let iMaxPoints = null
            // 调用getFeature方法，分析svg和生成数据
            let funName = iPlot.name.split('_')[1]
            // 获取绘制点数_名称最后一位
            const maxPnt = funName.substr(funName.length - 1, 1)
            // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
            if (!isNaN(maxPnt)) {
              iMaxPoints = parseInt(maxPnt)
              funName = funName.substr(0, funName.length - 1)
            }
            // console.log(funName)
            if (!funName) return
            // 查看方法是否存在，不存在退出！
            const func = plot.getFunc(funName)
            // 方法不存在退出绘制！
            if (!func) return
            // 查看控制点数是否满足绘制要求
            if (iMaxPoints) { // 是否有绘制控制点的数量要求
              if (iPlot.cp.length !== iMaxPoints) return
            }
            proxy.plot_geometries = func(iPlot.cp)
            // 设置样式添加到军标层
            const gID = iPlot.id
            // let iStyle = {
            iStyle = {
              fill: 'none', // proxy.currColor,
              stroke: iPlot.color,
              width: proxy.strokeWidth
            }
            // console.log(proxy.iType)
            // if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts') {
            //   iStyle.fill = iPlot.color
            //   iStyle.width = 0
            // }
            for (let i = 0; i < proxy.plot_geometries.geoData.length; i++) {
              // let iType = proxy.plot_geometries.geoData[i].type
              proxy.plot_geometries.geoData[i].gid = gID
              // proxy.plot_geometries.geoData[i].style = iStyle
              proxy.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
            }
            // 实心箭头和虚线箭头样式设置（需要调整-见下面）
            if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_pathArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
            }
            // 新添加的带轮线（箭头要填充！）
            if (iPlot.name === 'mult_getCyyLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#000000'
              proxy.plot_geometries.geoData[2].color = '#000000'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt) // 如果两个控制点，需要在添加一个
              }
            }
            // 摩托化行进
            if (iPlot.name === 'mult_getMotorLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt)
              }
            }
            // 伴随线
            if (iPlot.name === 'mult_getFollowLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#DEB887'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt)
              }
            }
            // 虚线的处理
            if (iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[1].style.lineDash = [20, 10]
            }
            // console.log(proxy.plot_geometries)
            // 将标绘图形加入标绘层
            proxy.geom2Featrue()
            // proxy.loadGeom2Featrue() --否：拖动控制点时颜色会变成当前色
            break
          case 'point':
            // console.log(iPlot)
            const xID = iPlot.id.substr(0, 4)
            if (xID === 'text') {
              const iText = iPlot.style.text
              iPlot.style.text = iText.replace(/\\n/g, '\n')
            }
            proxy.createTxtPlot(iPlot)
            break
          default:
          // 默认代码块
        }
        proxy.xData.push(iPlot)
        console.log(iPlot)
      }
      // 将xData重新调入
      // proxy.xData = plotData
      // console.log(proxy.xData)
    },
    // ----------------------------------------------------------------------------

    /**
     * @description 加载标绘数据，坐标系统一致
     * @param plotData {Object} 加载的军标数据
     * @return
     */
    async loadData (plotData) {
      // plotData = eval(plotData)

      // 删除已经绘制的数据,和军标绘制数据
      proxy.clearData()
      proxy.xData.splice(0, proxy.xData.length)
      // 添加时间戳--时间戳数据
      proxy.plotDataTime = new Date().getTime()
      // console.log(proxy.plotDataTime)
      // 循环绘制每一个军标

      for (let i = 0; i < plotData.length; i++) {
        const iPlot = plotData[i]
        const pName = iPlot.name
        // let id = iPlot.id
        // let cp = iPlot.cp
        // let bbox = iPlot.boxWH
        // let rotate = iPlot.rotate
        // let scale = iPlot.scale
        // let color = iPlot.color
        // let unit = iPlot.unit
        const style = iPlot.style
        let lineWidth = 0
        if (style) { // 如果有样式数据-初始为空
          if (style.width) { // 如果线有宽度设置
            lineWidth = style.width
          }
        }
        if (!lineWidth) {
          lineWidth = proxy.strokeWidth
        }
        // console.log(iPlot, lineWidth)
        let iType = pName.toLowerCase()
        const shortName = iType.substr(0, 4)
        if (shortName === 'icon' || shortName === 'dire' || shortName === 'mult' || shortName === 'hand' || shortName === 'ddir') {
          iType = shortName
        }
        // console.log(iType)
        // 根据类型绘制载入军标
        let iGeom = null
        let iFeature = null
        let iStyle = null
        let cp1 = null
        let cp2 = null
        let r = null
        switch (iType) {
          case 'linestring':
            // 绘制线
            iGeom = new LineString(iPlot.cp) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'polygon':
            // 绘制多边形
            // console.log(iPlot.cp)
            iGeom = new Polygon(iPlot.cp) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            if (iPlot.mark) {
              iFeature.set('mark', iPlot.mark)
            }
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'circle':
            if (iPlot.cp.length < 2) return // 圆需要两个控制点
            cp1 = iPlot.cp[0]
            cp2 = iPlot.cp[1]
            // 求两个点的距离(半径)--可能需要进行坐标转换，转换到3857，计算长度。（坐标转换）
            r = plot.CalLengthOfTwoPoints(cp1, cp2)
            // 绘制圆--new Circle(center, opt_radius)
            // iGeom = new geoCircle(iPlot.cp[0], iPlot.cp[1][0])  // 生成线所需点！
            iGeom = new geoCircle(cp1, r)
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'icon':
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            if (iPlot.cp.length > 0) {
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}；以下方法自动将地理坐标转换成品目坐标
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // console.log(proxy.plot_geometries)
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth iPlot.color
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              // 将军标绘制到标绘层（样式处理）
              proxy.geom2Featrue(proxy.plot_geometries)
            }
            break
          case 'dire':
          case 'ddir':
            // 绘制svg固定军标和方向军标
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // console.log(iPlot.name)
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name)
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            // 调用getFeature方法，分析svg和生成数据
            if (iPlot.cp.length > 1) {
              // 将地理坐标转换成屏幕坐标（createSVGPlot新方法中已经自动转换坐标）
              // let cp1 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[0]) // 控制点1：中心点
              // let cp2 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[1]) // 控制点2：方向点
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
              // proxy.plot_geometries = proxy.$refs.pVec.getFeature([cp1, cp2], iType, iPlot.name, proxy.iMap)
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // 将军标绘制到标绘层（样式处理）
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              proxy.geom2Featrue(proxy.plot_geometries)
              // proxy.createSVGPlot(iPlot)
            }
            break
          case 'mult':
            // 绘制方向自由变化军标；如：箭头
            let iMaxPoints = null
            // 调用getFeature方法，分析svg和生成数据
            let funName = iPlot.name.split('_')[1]
            // 获取绘制点数_名称最后一位
            const maxPnt = funName.substr(funName.length - 1, 1)
            // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
            if (!isNaN(maxPnt)) {
              iMaxPoints = parseInt(maxPnt)
              funName = funName.substr(0, funName.length - 1)
            }
            // console.log(funName)
            if (!funName) return
            // 查看方法是否存在，不存在退出！
            const func = plot.getFunc(funName)
            // 方法不存在退出绘制！
            if (!func) return
            // 查看控制点数是否满足绘制要求
            if (iMaxPoints) { // 是否有绘制控制点的数量要求
              if (iPlot.cp.length !== iMaxPoints) return
            }
            proxy.plot_geometries = func(iPlot.cp)
            // 设置样式添加到军标层
            const gID = iPlot.id
            // let iStyle = {
            iStyle = {
              fill: 'none', // proxy.currColor,
              stroke: iPlot.color,
              width: proxy.strokeWidth
            }
            // if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts') {
            //   iStyle.fill = iPlot.color
            //   iStyle.width = 0
            // }
            for (let i = 0; i < proxy.plot_geometries.geoData.length; i++) {
              // let iType = proxy.plot_geometries.geoData[i].type
              proxy.plot_geometries.geoData[i].gid = gID
              // proxy.plot_geometries.geoData[i].style = iStyle
              proxy.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
            }
            // 实心箭头和虚线箭头样式设置（需要调整-见下面）
            if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_pathArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
            }
            // 新添加的带轮线（箭头要填充！）
            if (iPlot.name === 'mult_getCyyLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#000000'
              proxy.plot_geometries.geoData[2].color = '#000000'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt) // 如果两个控制点，需要在添加一个
              }
            }
            // 摩托化行进
            if (iPlot.name === 'mult_getMotorLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt)
              }
            }
            // 伴随线
            if (iPlot.name === 'mult_getFollowLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#DEB887'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt)
              }
            }
            // 虚线的处理
            if (iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[1].style.lineDash = [20, 10]
            }
            // console.log(proxy.plot_geometries)
            // 将标绘图形加入标绘层
            proxy.geom2Featrue()
            // proxy.loadGeom2Featrue() --否：拖动控制点时颜色会变成当前色
            break
          case 'point':
            // console.log(iPlot)
            const xID = iPlot.id.substr(0, 4)
            if (xID === 'text') {
              const iText = iPlot.style.text
              iPlot.style.text = iText.replace(/\\n/g, '\n')
            }
            proxy.createTxtPlot(iPlot)
            break
          default:
          // 默认代码块
        }
      }
      // 将xData重新调入
      proxy.xData = plotData
      // console.log(proxy.xData)
    },

    /**
     * @description 加载标绘数据，保存数据坐标系与当前地图坐标系不同，不同需要转换坐标
     * @param plotData {Object} 加载的军标数据
     * @param dataRCS {String}} 军标数据坐标系
     * @param mapRCS {String} 当前地图坐标系
     * @return
     */
    async loadData2 (plotData, dataRCS, mapRCS) {
      // plotData = eval(plotData)
      const aPlotData = [] // 进行过坐标转换的新标绘数据
      // console.log(plotData)
      // 删除已经绘制的数据,和军标绘制数据
      proxy.clearData()
      proxy.xData.splice(0, proxy.xData.length)
      proxy.plotDataTime = new Date().getTime()
      // 循环绘制每一个军标

      for (let i = 0; i < plotData.length; i++) {
        const iPlot = plotData[i]
        const pName = iPlot.name
        // let id = iPlot.idconsole.log(aPlotCP)
        const aPlotCP = [] // iPlot.cp // 军标的控制点数组[[x,y],[x,y]...]
        // aPlotCP = olProj.transform(aPlotCP, dataRCS, mapRCS) // 进行坐标转换
        if (pName === 'Polygon') {
          // continue
          // 多边形数据格式[[ [多边形]，[多边形-挖孔]，... ]]
          console.log(iPlot.cp.length)
          for (let idx = 0; idx < iPlot.cp.length; idx++) {
            const aPloyData = [] // 多边形数据（多边形可能有挖孔多边形）
            for (let j = 0; j < iPlot.cp[idx].length; j++) {
              const aPnt = iPlot.cp[idx][j]
              // console.log(aPnt, iPlot.name)
              aPloyData.push(olProj.transform(aPnt, dataRCS, mapRCS))
            }
            aPlotCP.push(aPloyData)
          }
        } else {
          for (let j = 0; j < iPlot.cp.length; j++) {
            const aPnt = iPlot.cp[j]
            // console.log(aPnt, iPlot.name)
            aPlotCP.push(olProj.transform(aPnt, dataRCS, mapRCS))
          }
        }
        console.log(iPlot.cp, aPlotCP, dataRCS, mapRCS)
        iPlot.cp = aPlotCP
        aPlotData.push(iPlot) // 将坐标转换后的 plot对象 保存到新的数组中
        // let bbox = iPlot.boxWH
        // let rotate = iPlot.rotate
        // let scale = iPlot.scale
        // let color = iPlot.color
        // let unit = iPlot.unit
        const style = iPlot.style
        let lineWidth = 0
        if (style) { // 如果有样式数据-初始为空
          if (style.width) { // 如果线有宽度设置
            lineWidth = style.width
          }
        }
        if (!lineWidth) {
          lineWidth = proxy.strokeWidth
        }
        // console.log(iPlot, lineWidth)
        let iType = pName.toLowerCase()
        const shortName = iType.substr(0, 4)
        if (shortName === 'icon' || shortName === 'dire' || shortName === 'mult' || shortName === 'hand' || shortName === 'ddir') {
          iType = shortName
        }
        // console.log(iType)
        // 根据类型绘制载入军标
        let iGeom = null
        let iFeature = null
        let iStyle = null
        let cp1 = null
        let cp2 = null
        let r = null
        switch (iType) {
          case 'linestring':
            // 绘制线
            iGeom = new LineString(aPlotCP) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'polygon':
            // 绘制多边形
            // console.log(iPlot.cp)
            iGeom = new Polygon(aPlotCP) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'circle':
            if (iPlot.cp.length < 2) return // 圆需要两个控制点
            cp1 = aPlotCP[0]
            cp2 = aPlotCP[1]
            // 求两个点的距离(半径)--可能需要进行坐标转换，转换到3857，计算长度。（坐标转换）
            r = plot.CalLengthOfTwoPoints(cp1, cp2)
            // 绘制圆--new Circle(center, opt_radius)
            // iGeom = new geoCircle(iPlot.cp[0], iPlot.cp[1][0])  // 生成线所需点！
            iGeom = new geoCircle(cp1, r)
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'icon':
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写到 proxy.$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            if (aPlotCP.length > 0) {
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}；以下方法自动将地理坐标转换成品目坐标
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // console.log(proxy.plot_geometries)
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth iPlot.color
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              // 将军标绘制到标绘层（样式处理）
              proxy.geom2Featrue(proxy.plot_geometries)
            }
            break
          case 'dire':
          case 'ddir':
            // 绘制svg固定军标和方向军标
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // console.log(iPlot.name)
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name)
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            // 调用getFeature方法，分析svg和生成数据
            if (aPlotCP.length > 1) {
              // 将地理坐标转换成屏幕坐标（createSVGPlot新方法中已经自动转换坐标）
              // let cp1 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[0]) // 控制点1：中心点
              // let cp2 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[1]) // 控制点2：方向点
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
              // proxy.plot_geometries = proxy.$refs.pVec.getFeature([cp1, cp2], iType, iPlot.name, proxy.iMap)
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // 将军标绘制到标绘层（样式处理）
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              proxy.geom2Featrue(proxy.plot_geometries)
              // proxy.createSVGPlot(iPlot)
            }
            break
          case 'mult':
            // 绘制方向自由变化军标；如：箭头
            let iMaxPoints = null
            // 调用getFeature方法，分析svg和生成数据
            let funName = iPlot.name.split('_')[1]
            // 获取绘制点数_名称最后一位
            const maxPnt = funName.substr(funName.length - 1, 1)
            // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
            if (!isNaN(maxPnt)) {
              iMaxPoints = parseInt(maxPnt)
              funName = funName.substr(0, funName.length - 1)
            }
            // console.log(funName)
            if (!funName) return
            // 查看方法是否存在，不存在退出！
            const func = plot.getFunc(funName)
            // 方法不存在退出绘制！
            if (!func) return
            // 查看控制点数是否满足绘制要求
            if (iMaxPoints) { // 是否有绘制控制点的数量要求
              if (aPlotCP.length !== iMaxPoints) return
            }
            proxy.plot_geometries = func(aPlotCP)
            // 设置样式添加到军标层
            const gID = iPlot.id
            // let iStyle = {
            iStyle = {
              fill: 'none', // proxy.currColor,
              stroke: iPlot.color,
              width: proxy.strokeWidth
            }
            console.log(proxy.iType)
            // if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts') {
            //   iStyle.fill = iPlot.color
            //   iStyle.width = 0
            // }
            for (let i = 0; i < proxy.plot_geometries.geoData.length; i++) {
              // let iType = proxy.plot_geometries.geoData[i].type
              proxy.plot_geometries.geoData[i].gid = gID
              // proxy.plot_geometries.geoData[i].style = iStyle
              proxy.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
            }
            // 实心箭头和虚线箭头样式设置（需要调整-见下面）
            if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_pathArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
            }
            // 新添加的带轮线（箭头要填充！）
            if (iPlot.name === 'mult_getCyyLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#000000'
              proxy.plot_geometries.geoData[2].color = '#000000'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (aPlotCP.length === 2) {
                const cp1 = aPlotCP[0]
                const cp2 = aPlotCP[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                aPlotCP.splice(1, 0, midPnt) // 如果两个控制点，需要在添加一个
              }
            }
            // 摩托化行进
            if (iPlot.name === 'mult_getMotorLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (aPlotCP.length === 2) {
                const cp1 = aPlotCP[0]
                const cp2 = aPlotCP[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                aPlotCP.splice(1, 0, midPnt)
              }
            }
            // 伴随线
            if (iPlot.name === 'mult_getFollowLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#DEB887'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (aPlotCP.length === 2) {
                const cp1 = aPlotCP[0]
                const cp2 = aPlotCP[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                aPlotCP.splice(1, 0, midPnt)
              }
            }
            // 虚线的处理
            if (iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[1].style.lineDash = [20, 10]
            }
            // console.log(proxy.plot_geometries)
            // 将标绘图形加入标绘层
            proxy.geom2Featrue()
            // proxy.loadGeom2Featrue() --否：拖动控制点时颜色会变成当前色
            break
          case 'point':
            // console.log(iPlot)
            const xID = iPlot.id.substr(0, 4)
            if (xID === 'text') {
              const iText = iPlot.style.text
              iPlot.style.text = iText.replace(/\\n/g, '\n')
            }
            proxy.createTxtPlot(iPlot)
            break
          default:
          // 默认代码块
        }
      }
      // 将xData重新调入
      // proxy.xData = plotData
      proxy.xData = aPlotData
      // console.log(proxy.xData)
    },

    /**
     * @description 更新军标数据，用于协同添加其他人绘制的内容
     * @param plotData {Object} 加载的军标数据
     * @return
     */
    async updateData (plotData) {
      // plotData = eval(plotData)
      // 添加数据不需要删除数据
      // proxy.clearData()
      // proxy.xData.splice(0, proxy.xData.length)
      // 循环绘制每一个军标 idx -- 确定一下是删除
      for (let i = 0; i < plotData.length; i++) {
        const iPlot = plotData[i]
        const pName = iPlot.name
        const plotID = iPlot.id
        let isExist = false // 用来标识军标是否存在
        for (let idx = 0; idx < proxy.xData.length; idx++) {
          if (proxy.xData[idx].id === plotID) {
            isExist = true // 此条军标数据已存在
            break
          }
        }
        if (isExist) continue // 如果数据已经，跳过此条数据
        // let id = iPlot.id
        // let cp = iPlot.cp
        // let bbox = iPlot.boxWH
        // let rotate = iPlot.rotate
        // let scale = iPlot.scale
        // let color = iPlot.color
        // let unit = iPlot.unit
        const style = iPlot.style
        let lineWidth = 0
        if (style) { // 如果有样式数据-初始为空
          if (style.width) { // 如果线有宽度设置
            lineWidth = style.width
          }
        }
        if (!lineWidth) {
          lineWidth = proxy.strokeWidth
        }
        // console.log(iPlot, lineWidth)
        let iType = pName.toLowerCase()
        const shortName = iType.substr(0, 4)
        if (shortName === 'icon' || shortName === 'dire' || shortName === 'mult' || shortName === 'hand' || shortName === 'ddir') {
          iType = shortName
        }
        // console.log(iType)
        // 根据类型绘制载入军标
        let iGeom = null
        let iFeature = null
        let iStyle = null
        let cp1 = null
        let cp2 = null
        let r = null
        switch (iType) {
          case 'linestring':
            // 绘制线
            iGeom = new LineString(iPlot.cp) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'polygon':
            // 绘制多边形
            // console.log(iPlot.cp)
            iGeom = new Polygon(iPlot.cp) // 生成线所需点！
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            if (iPlot.mark) {
              iFeature.set('mark', iPlot.mark)
            }
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'circle':
            if (iPlot.cp.length < 2) return // 圆需要两个控制点
            cp1 = iPlot.cp[0]
            cp2 = iPlot.cp[1]
            // 求两个点的距离(半径)--可能需要进行坐标转换，转换到3857，计算长度。（坐标转换）
            r = plot.CalLengthOfTwoPoints(cp1, cp2)
            // 绘制圆--new Circle(center, opt_radius)
            // iGeom = new geoCircle(iPlot.cp[0], iPlot.cp[1][0])  // 生成线所需点！
            iGeom = new geoCircle(cp1, r)
            iFeature = new Feature(iGeom) // 生成feature
            // 需要添加控制点属性--待添加
            // iFeature.setProperties({gid:gID})
            iFeature.set('gid', iPlot.id)
            iFeature.set('type', 'PLOT')
            // 获取样式
            iStyle = iPlot.style
            // 设置样式
            iFeature.setStyle(new Style({
              fill: new Fill({ // ol.style.Fill
                color: iStyle.fill
              }),
              stroke: new Stroke({ // ol.style.Stroke
                color: iStyle.stroke,
                // width: iStyle.width,
                width: proxy.strokeWidth,
                lineDash: iStyle.lineDash
              })
            }))
            // 将绘制的军标加入军标层
            proxy.plottingLayer.getSource().addFeature(iFeature)
            break
          case 'icon':
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            if (iPlot.cp.length > 0) {
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}；以下方法自动将地理坐标转换成品目坐标
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // console.log(proxy.plot_geometries)
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth iPlot.color
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              // 将军标绘制到标绘层（样式处理）
              proxy.geom2Featrue(proxy.plot_geometries)
            }
            break
          case 'dire':
          case 'ddir':
            // 绘制svg固定军标和方向军标
            // 清空原有svg数据
            proxy.$refs.pVec.clearPlotData()
            // proxy.getPlotData(iPlot.name) // 调用军标绘制所需要的SVG -- 可能需要延时处理
            // console.log(iPlot.name)
            // proxy.$refs.pVec.svgData = await proxy.$refs.pVec.getPlotDataEx(iPlot.name)
            await proxy.getSVGDataByID(iPlot.name) // 替代上面的方法，调入要使用的SVG写道$refs.pVec.svgData中--先从内部数组获取
            // await proxy.sleep(100)
            // 调用getFeature方法，分析svg和生成数据
            if (iPlot.cp.length > 1) {
              // 将地理坐标转换成屏幕坐标（createSVGPlot新方法中已经自动转换坐标）
              // let cp1 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[0]) // 控制点1：中心点
              // let cp2 = proxy.iMap.getPixelFromCoordinate(iPlot.cp[1]) // 控制点2：方向点
              // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
              // proxy.plot_geometries = proxy.$refs.pVec.getFeature([cp1, cp2], iType, iPlot.name, proxy.iMap)
              proxy.plot_geometries = proxy.$refs.pVec.createSVGPlot(iPlot)
              // 将军标绘制到标绘层（样式处理）
              // proxy.setSVGStyle(proxy.plot_geometries, lineWidth) // proxy.strokeWidth
              proxy.setSVGStyle(proxy.plot_geometries, lineWidth, iPlot.color)
              proxy.geom2Featrue(proxy.plot_geometries)
              // proxy.createSVGPlot(iPlot)
            }
            break
          case 'mult':
            // 绘制方向自由变化军标；如：箭头
            let iMaxPoints = null
            // 调用getFeature方法，分析svg和生成数据
            let funName = iPlot.name.split('_')[1]
            // 获取绘制点数_名称最后一位
            const maxPnt = funName.substr(funName.length - 1, 1)
            // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
            if (!isNaN(maxPnt)) {
              iMaxPoints = parseInt(maxPnt)
              funName = funName.substr(0, funName.length - 1)
            }
            // console.log(funName)
            if (!funName) return
            // 查看方法是否存在，不存在退出！
            const func = plot.getFunc(funName)
            // 方法不存在退出绘制！
            if (!func) return
            // 查看控制点数是否满足绘制要求
            if (iMaxPoints) { // 是否有绘制控制点的数量要求
              if (iPlot.cp.length !== iMaxPoints) return
            }
            proxy.plot_geometries = func(iPlot.cp)
            // 设置样式添加到军标层
            const gID = iPlot.id
            // let iStyle = {
            iStyle = {
              fill: 'none', // proxy.currColor,
              stroke: iPlot.color,
              width: proxy.strokeWidth
            }
            console.log(proxy.iType)
            // if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts') {
            //   iStyle.fill = iPlot.color
            //   iStyle.width = 0
            // }
            for (let i = 0; i < proxy.plot_geometries.geoData.length; i++) {
              // let iType = proxy.plot_geometries.geoData[i].type
              proxy.plot_geometries.geoData[i].gid = gID
              // proxy.plot_geometries.geoData[i].style = iStyle
              proxy.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
            }
            // 实心箭头和虚线箭头样式设置（需要调整-见下面）
            if (iPlot.name === 'mult_getSSArrowPnts' || iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_pathArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
            }
            // 新添加的带轮线（箭头要填充！）
            if (iPlot.name === 'mult_getCyyLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#000000'
              proxy.plot_geometries.geoData[2].color = '#000000'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt) // 如果两个控制点，需要在添加一个
              }
            }
            // 摩托化行进
            if (iPlot.name === 'mult_getMotorLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt)
              }
            }
            // 伴随线
            if (iPlot.name === 'mult_getFollowLine') {
              // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
              proxy.plot_geometries.geoData[0].style.fill = iPlot.color
              proxy.plot_geometries.geoData[0].style.width = 0
              proxy.plot_geometries.geoData[2].style.stroke = '#DEB887'
              // console.log(proxy.currPlot, proxy.currPlot.cp.length)
              if (iPlot.cp.length === 2) {
                const cp1 = iPlot.cp[0]
                const cp2 = iPlot.cp[1]
                const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
                iPlot.cp.splice(1, 0, midPnt)
              }
            }
            // 虚线的处理
            if (iPlot.name === 'mult_dashArrowPnts' || iPlot.name === 'mult_dashPathArrowPnts') {
              proxy.plot_geometries.geoData[1].style.lineDash = [20, 10]
            }
            // console.log(proxy.plot_geometries)
            // 将标绘图形加入标绘层
            proxy.geom2Featrue()
            // proxy.loadGeom2Featrue() --否：拖动控制点时颜色会变成当前色
            break
          case 'point':
            // console.log(iPlot)
            const xID = iPlot.id.substr(0, 4)
            if (xID === 'text') {
              const iText = iPlot.style.text
              iPlot.style.text = iText.replace(/\\n/g, '\n')
            }
            proxy.createTxtPlot(iPlot)
            break
          default:
          // 默认代码块
        }
        // 添加军标数据到xData
        proxy.xData.push(plotData)
      }
      // 将xData重新调入，改由上面添加
      // proxy.xData = plotData
      // console.log(proxy.xData)
    },

    /**
     * @description 协同开关
     * @param plotData {Object} 加载的军标数据
     * @return
     */
    // syncPlotSwitch () {
    syncPlotSwitch (bOnOff) {
      // if (proxy.bSyncPlot) { // 开启标绘协同
      if (bOnOff) {
        if (proxy.timerID) return
        proxy.timerID = self.setInterval(() => {
          console.log('同步')
          proxy.savePlotData2DB()
          proxy.loadPlotData(false)
        }, proxy.loopTime)
      } else { // 关闭标绘协同
        if (proxy.timerID) {
          clearInterval(proxy.timerID)
          proxy.timerID = null
        }
      }
    },
    // 获取协同标志状态--是否启动协同
    getSyncPlotsState () {
      return proxy.bSyncPlot
    },
    setSyncPlotsState (bOnOff) {
      proxy.bSyncPlot = bOnOff
    }
    // 当前方法
  }
})
